home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / src / demos / audio / bz / bzlogo.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-02  |  8.6 KB  |  477 lines
  1. /*
  2.  * Copyright (C) 1992, 1993, 1994, Silicon Graphics, Inc.
  3.  * All Rights Reserved.
  4.  *
  5.  * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, Inc.;
  6.  * the contents of this file may not be disclosed to third parties, copied or
  7.  * duplicated in any form, in whole or in part, without the prior written
  8.  * permission of Silicon Graphics, Inc.
  9.  *
  10.  * RESTRICTED RIGHTS LEGEND:
  11.  * Use, duplication or disclosure by the Government is subject to restrictions
  12.  * as set forth in subdivision (c)(1)(ii) of the Rights in Technical Data
  13.  * and Computer Software clause at DFARS 252.227-7013, and/or in similar or
  14.  * successor clauses in the FAR, DOD or NASA FAR Supplement. Unpublished -
  15.  * rights reserved under the Copyright Laws of the United States.
  16.  */
  17. /***************************************************************************
  18.  *
  19.  * @(#) - BZLOGO - Convert an image to a logo for use in BZ.
  20.  *
  21.  *                    Chris Fouts - Silicon Graphics, Inc.
  22.  *                    February, 1992
  23.  **************************************************************************/
  24. #include <stdio.h>
  25. #include <fcntl.h>
  26. #include <string.h>
  27. #include <image.h>
  28. #include <vect.h>
  29. #include <objfnt.h>
  30. #include <sgiobj.h>
  31. #include <obj.h>
  32. #include <stream.h>
  33. #include <mesh.h>
  34.  
  35. #define    SCALE    100.0
  36.  
  37. #define BZLOGO_MAGIC    0x425a4c00
  38.  
  39. #define X(x) (int)( ( (x - xmin) * SCALE ) )
  40. #define Y(y) (int)( ( (y - ymin) * SCALE ) )
  41.  
  42. #define    MIN(a,b)    ( ( (a) < (b) ) ? (a) : (b) )
  43. #define    MAX(a,b)    ( ( (a) > (b) ) ? (a) : (b) )
  44.  
  45. static char    *base_name ;
  46.  
  47. extern short    *shortimagedata() ;
  48. extern sgiobj    *getfaces() ;
  49.  
  50. static FILE    *bzl_f ;
  51.  
  52. static sgiobj *meshchar(
  53.     short *sptr
  54.     )
  55. {
  56.     float    x ;
  57.     float    y ;
  58.     vect    p0 ;
  59.     vect    p1 ;
  60.     vect    s ;
  61.     vect    l ;
  62.     vect    c ;
  63.     int        nverts ;
  64.     int        npnts ;
  65.  
  66.     tempbegin() ;
  67.     p0.x = 0.0 ;
  68.     p0.y = 0.0 ;
  69.     p1.x = 1.0 ;
  70.     p1.y = 0.0 ;
  71.     tempsegment( &p0, 0, &p1, 0 ) ;
  72.  
  73.     pathbegin() ;
  74.     while( 1 ) {
  75.         switch(*sptr++) {
  76.             case PO_BGNLOOP :
  77.                 npnts = 0 ;
  78.                 break ;
  79.             case PO_ENDBGNLOOP :
  80.                 pathsegment( &l, 0, &s, 0 ) ;
  81.                 pathclose() ;
  82.                 npnts = 0 ;
  83.                 break ;
  84.             case PO_RETENDLOOP :
  85.                 pathsegment( &l, 0, &s, 0 ) ;
  86.                 pathclose() ;
  87.                 return getfaces() ;
  88.                 break ;
  89.             case PO_RET :
  90.                 return 0 ;
  91.                 break ;
  92.             }
  93.         nverts = *sptr++ ;
  94.         while( nverts-- ) {
  95.             if( npnts++ == 0 ) {
  96.                 l.x = s.x = sptr[0] ;
  97.                 l.y = s.y = sptr[1] ;
  98.                 }
  99.             else {
  100.                 c.x = sptr[0] ;
  101.                 c.y = sptr[1] ;
  102.                 pathsegment( &l, 0, &c, 0 ) ;
  103.                 l = c ;
  104.                 }
  105.             sptr+=2 ;
  106.             }
  107.         }
  108. }
  109.  
  110.  
  111.  
  112. static int obj_to_short(
  113.     object *path,
  114.     short *chardata,
  115.     int    len
  116.     )
  117. {
  118.     float    xmin ;
  119.     float    ymin ;
  120.     float    xmax ;
  121.     float    ymax ;
  122.     int        width ;
  123.     int        nshorts ;
  124.     int        pcnt ;
  125.     object    *pobj ;
  126.     point    *apnt ;
  127.  
  128.     xmin = ymin =  1E10;
  129.     xmax = ymax = -1E10;
  130.  
  131.     pobj = path;
  132.  
  133.     while( pobj ) {
  134.         if( ( apnt = pobj->points ) != NULL ) {
  135.             while( apnt ) {
  136.                 xmin = MIN( xmin, apnt->x ) ;
  137.                 ymin = MIN( ymin, apnt->y ) ;
  138.                 xmax = MAX( xmax, apnt->x ) ;
  139.                 ymax = MAX( ymax, apnt->y ) ;
  140.                 apnt = apnt->next ;
  141.                 }
  142.             }
  143.         pobj = pobj->next ;
  144.         }
  145.  
  146.     width = SCALE * ( xmax - xmin ) ;
  147.     ymin = 0.3333 ;
  148.  
  149.     nshorts = 0 ;
  150.     pobj = path ;
  151.     while( pobj ) {
  152.         if( ( apnt = pobj->points ) != NULL ) {
  153.             if( nshorts == 0 )
  154.                 chardata[nshorts++] = PO_BGNLOOP ;
  155.             else
  156.                 chardata[nshorts++] = PO_ENDBGNLOOP ;
  157.             pcnt = 0 ;
  158.             while( apnt ) {
  159.                 pcnt++ ;
  160.                 apnt = apnt->next ;
  161.                 }
  162.             chardata[nshorts++] = pcnt ;
  163.             apnt = pobj->points ;
  164.             while( apnt ) {
  165.                 chardata[nshorts++] = X(apnt->x) ;
  166.                 chardata[nshorts++] = Y(apnt->y) ;
  167.                 apnt = apnt->next ;
  168.                 }
  169.             }
  170.         pobj = pobj->next;
  171.         }
  172.     chardata[nshorts++] = PO_RETENDLOOP ;
  173.  
  174.     return( nshorts ) ;
  175. }
  176.  
  177.  
  178.  
  179. sgiobj *cvttotmesh(
  180.     sgiobj *obj
  181.     )
  182. {
  183.     sgiobj *robj ;
  184.  
  185.     robj = tmeshobj( obj ) ;
  186.     freesgiobj( obj ) ;
  187.  
  188.     return( robj ) ;
  189. }
  190.  
  191.  
  192.  
  193. static void outcmd(
  194.     char *cmd
  195.     )
  196. {
  197.     fputs( cmd, bzl_f ) ;
  198.     fputc( '\n', bzl_f ) ;
  199. }
  200.  
  201.  
  202.  
  203. static void outuchar(
  204.     unsigned char val1
  205.     )
  206. {
  207.     fprintf( bzl_f, "   %d\n", (int)val1 ) ;
  208. }
  209.  
  210.  
  211.  
  212. static void outucharpair(
  213.     unsigned char val1,
  214.     unsigned char val2
  215.     )
  216. {
  217.     fprintf( bzl_f, "   %d %d\n", (int)val1, (int)val2 ) ;
  218. }
  219.  
  220.  
  221.  
  222. static int limit_mesh(
  223.     sgiobj *obj,
  224.     float *xmin,
  225.     float *xmax,
  226.     float *ymin,
  227.     float *ymax
  228.     )
  229. {
  230.     long    *data;
  231.     char    *vertdata ;
  232.     char    *avert ;
  233.     int        vertlongs ;
  234.     int        nverts ;
  235.     float    *fptr;
  236.     int        cnt = 0 ;
  237.  
  238.     *xmin =  1e30 ;
  239.     *xmax = -1e30 ;
  240.     *ymin =  1e30 ;
  241.     *ymax = -1e30 ;
  242.  
  243.     data = obj->data ;
  244.     vertlongs = *data++ ;
  245.     vertdata = (char *)data ;
  246.     data += vertlongs ;
  247.     while( 1 ) {
  248.         switch( *data++ ) {
  249.             case OP_BGNTMESH :
  250.                 cnt++ ;
  251.                 break ;
  252.             case OP_SWAPTMESH :
  253.                 cnt++ ;
  254.                 break;
  255.             case OP_ENDBGNTMESH :
  256.                 cnt++ ;
  257.                 break ;
  258.             case OP_ENDTMESH :
  259.                 cnt++ ;
  260.                 return( cnt ) ;
  261.                 break ;
  262.             default :
  263.                 fprintf( stderr, "drawsgiobj: bad tmesh op %d\n", *data ) ;
  264.                 return( 0 ) ;
  265.                 break ;
  266.             }
  267.         nverts = *data++ ;
  268.         cnt++ ;
  269.         while( nverts-- ) {
  270.             avert = vertdata + *data++ ;
  271.             fptr = (float*)( avert + ( sizeof(long) * OFFSET_POINT ) ) ;
  272.             if( fptr[0] < *xmin ) *xmin = fptr[0] ;
  273.             if( fptr[1] < *ymin ) *ymin = fptr[1] ;
  274.             if( fptr[0] > *xmax ) *xmax = fptr[0] ;
  275.             if( fptr[1] > *ymax ) *ymax = fptr[1] ;
  276.             cnt += 2 ;
  277.             }
  278.         }
  279. }
  280.  
  281.  
  282.  
  283. static int save_mesh(
  284.     sgiobj *obj
  285.     )
  286. {
  287.     long    *data;
  288.     char    *vertdata ;
  289.     char    *avert ;
  290.     int        vertlongs ;
  291.     int        nverts ;
  292.     float    *fptr;
  293.     int        cnt ;
  294.     float    xmin ;
  295.     float    xmax ;
  296.     float    ymin ;
  297.     float    ymax ;
  298.     float    xmid ;
  299.     float    ymid ;
  300.     float    scale ;
  301.  
  302.     if( ( cnt = limit_mesh( obj, &xmin, &xmax, &ymin, &ymax ) ) == 0 ) {
  303.         return( 0 ) ;
  304.         }
  305.  
  306.     if( xmax == xmin && ymax == ymin ) {
  307.         fprintf( stderr, "%s:  no image picked out\n", basename ) ;
  308.         exit( 1 ) ;
  309.         }
  310.  
  311.     if( ymax - ymin > xmax - xmin ) {
  312.         scale = 255.0 / ( ymax - ymin ) ;
  313.         }
  314.     else {
  315.         scale = 255.0 / ( xmax - xmin ) ;
  316.         }
  317.     xmid = ( 255.0 - scale * ( xmax - xmin ) ) / 2. ;
  318.     ymid = ( 255.0 - scale * ( ymax - ymin ) ) / 2. ;
  319.  
  320.     data = obj->data ;
  321.     vertlongs = *data++ ;
  322.     vertdata = (char *)data ;
  323.     data += vertlongs ;
  324.     while( 1 ) {
  325.         switch( *data++ ) {
  326.             case OP_BGNTMESH :
  327.                 outcmd( "BGNTMESH" ) ;
  328.                 break ;
  329.             case OP_SWAPTMESH :
  330.                 outcmd( "SWAPTMESH" ) ;
  331.                 break;
  332.             case OP_ENDBGNTMESH :
  333.                 outcmd( "ENDBGNTMESH" ) ;
  334.                 break ;
  335.             case OP_ENDTMESH :
  336.                 outcmd( "RETENDTMESH" ) ;
  337.                 return( cnt ) ;
  338.                 break ;
  339.             default :
  340.                 fprintf( stderr, "%s: bad tmesh op %d\n", basename, *data ) ;
  341.                 return( 0 ) ;
  342.                 break ;
  343.             }
  344.         nverts = *data++ ;
  345.         outuchar( (unsigned char)nverts ) ;
  346.         while( nverts-- ) {
  347.             avert = vertdata + *data++ ;
  348.             fptr = (float*)( avert + ( sizeof(long) * OFFSET_POINT ) ) ;
  349.             outucharpair( (unsigned char)( scale * ( fptr[0]-xmin ) +xmid ) ,
  350.                           (unsigned char)( scale * ( fptr[1]-ymin ) +ymid ) ) ;
  351.             }
  352.         }
  353. }
  354.  
  355.  
  356.  
  357. static void usage( void )
  358. {
  359.     fprintf( stderr, "Usage: %s image out.bzl [-left | -right] [stepsize]\n",
  360.              base_name ) ;
  361.     exit( 1 ) ;
  362. }
  363.  
  364.  
  365.  
  366. main(
  367.     int argc,
  368.     char **argv
  369.     )
  370. {
  371.     objfnt    *fnt ;
  372.     sgiobj    *obj ;
  373.     short    *imgdata ;
  374.     object    *path ;
  375.     int        xsize ;
  376.     int        ysize ;
  377.     float    stepsize = 2.0 ;
  378.     short    chardata[10000] ;
  379.     IMAGE    *image ;
  380.     long    magic ;
  381.     int        n ;
  382.     int        side = 0 ;
  383.  
  384.     if( ( base_name = strrchr( argv[0], '/' ) ) == NULL ) {
  385.         base_name = argv[0] ;
  386.         }
  387.     else {
  388.         base_name++ ;
  389.         }
  390.  
  391.     if( argc < 3 ) {
  392.         usage() ;
  393.         exit( 1 ) ;
  394.         }
  395.  
  396.     if( ( bzl_f = fopen( argv[2], "w" ) ) == NULL ) {
  397.         perror( argv[2] ) ;
  398.         exit( 1 ) ;
  399.         }
  400.     fputs( "# BZLOGO Version 1.1\n", bzl_f ) ;
  401.  
  402.     n = 3 ;
  403.     while( argc > n ) {
  404.         if( strcmp( argv[n], "-left" ) == 0 ) {
  405.             side |= 1 ;
  406.             }
  407.         else if( strcmp( argv[n], "-right" ) == 0 ) {
  408.             side |= 2 ;
  409.             }
  410.         else {
  411.             stepsize = atof( argv[n] ) ;
  412.             if( stepsize < 0.1 )
  413.                 stepsize = 0.1 ;
  414.             }
  415.         n++ ;
  416.         }
  417.     printf( "stepsize = %f\n", stepsize ) ;
  418.  
  419.     switch( side ) {
  420.         case 0 :
  421.             break ;
  422.         case 1 :
  423.             fputs( "LEFTSIDE\n", bzl_f ) ;
  424.             break ;
  425.         case 2 :
  426.             fputs( "RIGHTSIDE\n", bzl_f ) ;
  427.             break ;
  428.         default :
  429.             usage() ;
  430.             break ;
  431.         }
  432.  
  433.     /*
  434.      * Read in image and store in imgdata.
  435.      */
  436.     if( ( imgdata = (short *)shortimagedata( argv[1] ) ) == NULL ) {
  437.         fprintf( stderr, "%s:  could not open image `%s'\n", base_name,
  438.                  argv[1] ) ;
  439.         exit( 1 ) ;
  440.         }
  441.  
  442.     sizeofimage( argv[1], &xsize, &ysize ) ;
  443.  
  444.     path = fbtoshape( imgdata, xsize, ysize, 128,
  445.                       RESAMPLEFUNC|SMOOTHFUNC|FIXCORNERFUNC,stepsize);
  446.     if( path == NULL ) {
  447.         fprintf( stderr, "%s:  image is either all white or all black\n",
  448.                  base_name ) ;
  449.         exit( 1 ) ;
  450.         }
  451.  
  452.     /*
  453.      * Convert raster to outline format in chardata.
  454.      */
  455.     obj_to_short( path, chardata, 10000 ) ;
  456.     freeobj( path );
  457.  
  458.     /*
  459.      * Convert from outline to triangular mesh.
  460.      */
  461.     pathnoise( 0.000 ) ;
  462.     if( ( obj = meshchar( chardata ) ) == NULL ) {
  463.         fprintf( stderr, "%s:  could not mesh the image.\n", base_name ) ;
  464.         exit( 1 ) ;
  465.         }
  466.  
  467.     obj = cvttotmesh( obj ) ;
  468.  
  469.     printf( "%d words\n", save_mesh( obj ) ) ;
  470.  
  471.     fclose( bzl_f ) ;
  472.     return( 0 ) ;
  473. }
  474.  
  475.  
  476.  
  477.